1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
2
 
2
 
 
 
 
2
 
2
 
2
2
2
 
 
 
 
1
 
 
 
 
 
 
2
 
 
 
2
 
 
 
2
 
2
 
 
 
 
 
 
 
1
2
 
 
 
 
 
2
 
 
2
 
 
2
2
 
1
 
 
 
2
 
 
1
1
1
 
1
1
 
 
1
1
 
1
 
 
1
 
2
 
 
 
 
 
1
 
1
 
1
 
 
 
 
1
2
2
2
2
2
2
1
 
 
2
2
 
 
 
 
2
 
 
 
1
3
1
 
 
 
1
1
 
 
 
 
 
 
 
1
 
1
1
1
 
1
 
1
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
1
 
 
 
 
 
 
 
 
 
 
 
1
 
 
6
6
 
1
 
2
 
1
 
2
 
 
 
 
1
1
 
1
 
 
1
 
 
 
 
 
 
 
1
 
 
1
1
 
 
1
1
 
1
1
1
1
1
1
1
 
1
1
 
1
 
 
 
 
/*
example.js
 
quickstart example
 
instruction
    1. save this script as example.js
    2. run the shell command:
        $ npm install npmtest-sugar && PORT=8081 node example.js
    3. play with the browser-demo on http://127.0.0.1:8081
*/
 
 
 
/* istanbul instrument in package npmtest_sugar */
/*jslint
    bitwise: true,
    browser: true,
    maxerr: 8,
    maxlen: 96,
    node: true,
    nomen: true,
    regexp: true,
    stupid: true
*/
(function () {
    'use strict';
    var local;
 
 
 
    // run shared js-env code - pre-init
    (function () {
        // init local
        local = {};
        // init modeJs
        local.modeJs = (function () {
            try {
                return typeof navigator.userAgent === 'string' &&
                    typeof document.querySelector('body') === 'object' &&
                    typeof XMLHttpRequest.prototype.open === 'function' &&
                    'browser';
            } catch (errorCaughtBrowser) {
                return module.exports &&
                    typeof process.versions.node === 'string' &&
                    typeof require('http').createServer === 'function' &&
                    'node';
            }
        }());
        // init global
        local.global = local.modeJs === 'browser'
            ? window
            : global;
        // init utility2_rollup
        local = local.global.utility2_rollup || (local.modeJs === 'browser'
            ? local.global.utility2_npmtest_sugar
            : global.utility2_moduleExports);
        // export local
        local.global.local = local;
    }());
    switch (local.modeJs) {
 
 
 
    // post-init
    // run browser js-env code - post-init
    /* istanbul ignore next */
    case 'browser':
        local.testRunBrowser = function (event) {
            Eif (!event || (event &&
                    event.currentTarget &&
                    event.currentTarget.className &&
                    event.currentTarget.className.includes &&
                    event.currentTarget.className.includes('onreset'))) {
                // reset output
                Array.from(
                    document.querySelectorAll('body > .resettable')
                ).forEach(function (element) {
                    switch (element.tagName) {
                    case 'INPUT':
                    case 'TEXTAREA':
                        element.value = '';
                        break;
                    default:
                        element.textContent = '';
                    }
                });
            }
            switch (event && event.currentTarget && event.currentTarget.id) {
            case 'testRunButton1':
                // show tests
                Eif (document.querySelector('#testReportDiv1').style.display === 'none') {
                    document.querySelector('#testReportDiv1').style.display = 'block';
                    document.querySelector('#testRunButton1').textContent =
                        'hide internal test';
                    local.modeTest = true;
                    local.testRunDefault(local);
                // hide tests
                } else {
                    document.querySelector('#testReportDiv1').style.display = 'none';
                    document.querySelector('#testRunButton1').textContent = 'run internal test';
                }
                break;
            // custom-case
            default:
                break;
            }
            Iif (document.querySelector('#inputTextareaEval1') && (!event || (event &&
                    event.currentTarget &&
                    event.currentTarget.className &&
                    event.currentTarget.className.includes &&
                    event.currentTarget.className.includes('oneval')))) {
                // try to eval input-code
                try {
                    /*jslint evil: true*/
                    eval(document.querySelector('#inputTextareaEval1').value);
                } catch (errorCaught) {
                    console.error(errorCaught);
                }
            }
        };
        // log stderr and stdout to #outputTextareaStdout1
        ['error', 'log'].forEach(function (key) {
            console[key + '_original'] = console[key];
            console[key] = function () {
                var element;
                console[key + '_original'].apply(console, arguments);
                element = document.querySelector('#outputTextareaStdout1');
                Iif (!element) {
                    return;
                }
                // append text to #outputTextareaStdout1
                element.value += Array.from(arguments).map(function (arg) {
                    return typeof arg === 'string'
                        ? arg
                        : JSON.stringify(arg, null, 4);
                }).join(' ') + '\n';
                // scroll textarea to bottom
                element.scrollTop = element.scrollHeight;
            };
        });
        // init event-handling
        ['change', 'click', 'keyup'].forEach(function (event) {
            Array.from(document.querySelectorAll('.on' + event)).forEach(function (element) {
                element.addEventListener(event, local.testRunBrowser);
            });
        });
        // run tests
        local.testRunBrowser();
        break;
 
 
 
    // run node js-env code - post-init
    /* istanbul ignore next */
    case 'node':
        // export local
        module.exports = local;
        // require modules
        local.fs = require('fs');
        local.http = require('http');
        local.url = require('url');
        // init assets
        local.assetsDict = local.assetsDict || {};
        /* jslint-ignore-begin */
        local.assetsDict['/assets.index.template.html'] = '\
<!doctype html>\n\
<html lang="en">\n\
<head>\n\
<meta charset="UTF-8">\n\
<meta name="viewport" content="width=device-width, initial-scale=1">\n\
<title>{{env.npm_package_name}} (v{{env.npm_package_version}})</title>\n\
<style>\n\
/*csslint\n\
    box-sizing: false,\n\
    universal-selector: false\n\
*/\n\
* {\n\
    box-sizing: border-box;\n\
}\n\
body {\n\
    background: #dde;\n\
    font-family: Arial, Helvetica, sans-serif;\n\
    margin: 2rem;\n\
}\n\
body > * {\n\
    margin-bottom: 1rem;\n\
}\n\
.utility2FooterDiv {\n\
    margin-top: 20px;\n\
    text-align: center;\n\
}\n\
</style>\n\
<style>\n\
/*csslint\n\
*/\n\
textarea {\n\
    font-family: monospace;\n\
    height: 10rem;\n\
    width: 100%;\n\
}\n\
textarea[readonly] {\n\
    background: #ddd;\n\
}\n\
</style>\n\
</head>\n\
<body>\n\
<!-- utility2-comment\n\
<div id="ajaxProgressDiv1" style="background: #d00; height: 2px; left: 0; margin: 0; padding: 0; position: fixed; top: 0; transition: background 0.5s, width 1.5s; width: 25%;"></div>\n\
utility2-comment -->\n\
<h1>\n\
<!-- utility2-comment\n\
    <a\n\
        {{#if env.npm_package_homepage}}\n\
        href="{{env.npm_package_homepage}}"\n\
        {{/if env.npm_package_homepage}}\n\
        target="_blank"\n\
    >\n\
utility2-comment -->\n\
        {{env.npm_package_name}} (v{{env.npm_package_version}})\n\
<!-- utility2-comment\n\
    </a>\n\
utility2-comment -->\n\
</h1>\n\
<h3>{{env.npm_package_description}}</h3>\n\
<!-- utility2-comment\n\
<h4><a download href="assets.app.js">download standalone app</a></h4>\n\
<button class="onclick onreset" id="testRunButton1">run internal test</button><br>\n\
<div id="testReportDiv1" style="display: none;"></div>\n\
utility2-comment -->\n\
\n\
\n\
\n\
<label>stderr and stdout</label>\n\
<textarea class="resettable" id="outputTextareaStdout1" readonly></textarea>\n\
<!-- utility2-comment\n\
{{#if isRollup}}\n\
<script src="assets.app.js"></script>\n\
{{#unless isRollup}}\n\
utility2-comment -->\n\
<script src="assets.utility2.rollup.js"></script>\n\
<script src="jsonp.utility2._stateInit?callback=window.utility2._stateInit"></script>\n\
<script src="assets.npmtest_sugar.rollup.js"></script>\n\
<script src="assets.example.js"></script>\n\
<script src="assets.test.js"></script>\n\
<!-- utility2-comment\n\
{{/if isRollup}}\n\
utility2-comment -->\n\
<div class="utility2FooterDiv">\n\
    [ this app was created with\n\
    <a href="https://github.com/kaizhu256/node-utility2" target="_blank">utility2</a>\n\
    ]\n\
</div>\n\
</body>\n\
</html>\n\
';
        /* jslint-ignore-end */
        Iif (local.templateRender) {
            local.assetsDict['/'] = local.templateRender(
                local.assetsDict['/assets.index.template.html'],
                {
                    env: local.objectSetDefault(local.env, {
                        npm_package_description: 'the greatest app in the world!',
                        npm_package_name: 'my-app',
                        npm_package_nameAlias: 'my_app',
                        npm_package_version: '0.0.1'
                    })
                }
            );
        } else {
            local.assetsDict['/'] = local.assetsDict['/assets.index.template.html']
                .replace((/\{\{env\.(\w+?)\}\}/g), function (match0, match1) {
                    // jslint-hack
                    String(match0);
                    switch (match1) {
                    case 'npm_package_description':
                        return 'the greatest app in the world!';
                    case 'npm_package_name':
                        return 'my-app';
                    case 'npm_package_nameAlias':
                        return 'my_app';
                    case 'npm_package_version':
                        return '0.0.1';
                    }
                });
        }
        // run the cli
        Eif (local.global.utility2_rollup || module !== require.main) {
            break;
        }
        local.assetsDict['/assets.example.js'] =
            local.assetsDict['/assets.example.js'] ||
            local.fs.readFileSync(__filename, 'utf8');
        local.assetsDict['/assets.npmtest_sugar.rollup.js'] =
            local.assetsDict['/assets.npmtest_sugar.rollup.js'] ||
            local.fs.readFileSync(
                // buildCustomOrg-hack
                local.npmtest_sugar.__dirname +
                    '/lib.npmtest_sugar.js',
                'utf8'
            ).replace((/^#!/), '//');
        local.assetsDict['/favicon.ico'] = local.assetsDict['/favicon.ico'] || '';
        // if $npm_config_timeout_exit exists,
        // then exit this process after $npm_config_timeout_exit ms
        if (Number(process.env.npm_config_timeout_exit)) {
            setTimeout(process.exit, Number(process.env.npm_config_timeout_exit));
        }
        // start server
        if (local.global.utility2_serverHttp1) {
            break;
        }
        process.env.PORT = process.env.PORT || '8081';
        console.error('server starting on port ' + process.env.PORT);
        local.http.createServer(function (request, response) {
            request.urlParsed = local.url.parse(request.url);
            if (local.assetsDict[request.urlParsed.pathname] !== undefined) {
                response.end(local.assetsDict[request.urlParsed.pathname]);
                return;
            }
            response.statusCode = 404;
            response.end();
        }).listen(process.env.PORT);
        break;
    }
}());
 
 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
 
 
 
 
 
 
 
 
 
 
 
2
 
2
 
 
 
 
2
 
2
 
2
2
2
 
 
 
 
1
 
 
 
 
 
 
2
 
 
 
2
 
2
 
2
1
 
1
1
1
 
 
 
 
 
/* istanbul instrument in package npmtest_sugar */
/*jslint
    bitwise: true,
    browser: true,
    maxerr: 8,
    maxlen: 96,
    node: true,
    nomen: true,
    regexp: true,
    stupid: true
*/
(function () {
    'use strict';
    var local;
 
 
 
    // run shared js-env code - pre-init
    (function () {
        // init local
        local = {};
        // init modeJs
        local.modeJs = (function () {
            try {
                return typeof navigator.userAgent === 'string' &&
                    typeof document.querySelector('body') === 'object' &&
                    typeof XMLHttpRequest.prototype.open === 'function' &&
                    'browser';
            } catch (errorCaughtBrowser) {
                return module.exports &&
                    typeof process.versions.node === 'string' &&
                    typeof require('http').createServer === 'function' &&
                    'node';
            }
        }());
        // init global
        local.global = local.modeJs === 'browser'
            ? window
            : global;
        // init utility2_rollup
        local = local.global.utility2_rollup || local;
        // init lib
        local.local = local.npmtest_sugar = local;
        // init exports
        if (local.modeJs === 'browser') {
            local.global.utility2_npmtest_sugar = local;
        } else {
            module.exports = local;
            module.exports.__dirname = __dirname;
            module.exports.module = module;
        }
    }());
}());
 
 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
 
 
 
 
 
 
 
 
 
 
 
2
 
2
 
 
 
 
2
 
2
 
2
2
2
 
 
 
 
1
 
 
 
 
 
 
2
 
 
2
 
 
1
 
 
 
1
 
 
1
 
1
 
 
2
 
 
 
 
 
2
2
 
2
 
 
 
 
 
1
 
 
 
 
 
1
 
 
 
 
 
2
2
 
2
 
 
 
 
 
 
1
 
 
1
 
 
 
 
 
 
1
 
 
 
 
 
 
1
1
 
 
1
 
 
 
 
 
 
1
1
1
1
1
1
 
 
1
 
 
 
 
2
2
 
 
1
 
 
 
 
 
 
2
2
 
 
1
 
 
 
 
 
 
2
2
 
 
1
 
 
 
 
 
 
2
2
 
 
1
 
 
 
 
 
 
1
1
 
 
 
1
1
 
 
 
 
/* istanbul instrument in package npmtest_sugar */
/*jslint
    bitwise: true,
    browser: true,
    maxerr: 8,
    maxlen: 96,
    node: true,
    nomen: true,
    regexp: true,
    stupid: true
*/
(function () {
    'use strict';
    var local;
 
 
 
    // run shared js-env code - pre-init
    (function () {
        // init local
        local = {};
        // init modeJs
        local.modeJs = (function () {
            try {
                return typeof navigator.userAgent === 'string' &&
                    typeof document.querySelector('body') === 'object' &&
                    typeof XMLHttpRequest.prototype.open === 'function' &&
                    'browser';
            } catch (errorCaughtBrowser) {
                return module.exports &&
                    typeof process.versions.node === 'string' &&
                    typeof require('http').createServer === 'function' &&
                    'node';
            }
        }());
        // init global
        local.global = local.modeJs === 'browser'
            ? window
            : global;
        switch (local.modeJs) {
        // re-init local from window.local
        case 'browser':
            local = local.global.utility2.objectSetDefault(
                local.global.utility2_rollup || local.global.local,
                local.global.utility2
            );
            break;
        // re-init local from example.js
        case 'node':
            local = (local.global.utility2_rollup || require('utility2'))
                .requireExampleJsFromReadme();
            break;
        }
        // export local
        local.global.local = local;
    }());
 
 
 
    // run shared js-env code - function
    (function () {
        return;
    }());
    switch (local.modeJs) {
 
 
 
    // run browser js-env code - function
    case 'browser':
        break;
 
 
 
    // run node js-env code - function
    case 'node':
        break;
    }
 
 
 
    // run shared js-env code - post-init
    (function () {
        return;
    }());
    switch (local.modeJs) {
 
 
 
    // run browser js-env code - post-init
    case 'browser':
        // run tests
        local.nop(local.modeTest &&
            document.querySelector('#testRunButton1') &&
            document.querySelector('#testRunButton1').click());
        break;
 
 
 
    // run node js-env code - post-init
    /* istanbul ignore next */
    case 'node':
        local.testCase_buildApidoc_default = local.testCase_buildApidoc_default || function (
            options,
            onError
        ) {
        /*
         * this function will test buildApidoc's default handling-behavior-behavior
         */
            options = { modulePathList: module.paths };
            local.buildApidoc(options, onError);
        };
 
        local.testCase_buildApp_default = local.testCase_buildApp_default || function (
            options,
            onError
        ) {
        /*
         * this function will test buildApp's default handling-behavior-behavior
         */
            local.testCase_buildReadme_default(options, local.onErrorThrow);
            local.testCase_buildLib_default(options, local.onErrorThrow);
            local.testCase_buildTest_default(options, local.onErrorThrow);
            local.testCase_buildCustomOrg_default(options, local.onErrorThrow);
            options = [];
            local.buildApp(options, onError);
        };
 
        local.testCase_buildCustomOrg_default = local.testCase_buildCustomOrg_default ||
            function (options, onError) {
            /*
             * this function will test buildCustomOrg's default handling-behavior
             */
                options = {};
                local.buildCustomOrg(options, onError);
            };
 
        local.testCase_buildLib_default = local.testCase_buildLib_default || function (
            options,
            onError
        ) {
        /*
         * this function will test buildLib's default handling-behavior
         */
            options = {};
            local.buildLib(options, onError);
        };
 
        local.testCase_buildReadme_default = local.testCase_buildReadme_default || function (
            options,
            onError
        ) {
        /*
         * this function will test buildReadme's default handling-behavior-behavior
         */
            options = {};
            local.buildReadme(options, onError);
        };
 
        local.testCase_buildTest_default = local.testCase_buildTest_default || function (
            options,
            onError
        ) {
        /*
         * this function will test buildTest's default handling-behavior
         */
            options = {};
            local.buildTest(options, onError);
        };
 
        local.testCase_webpage_default = local.testCase_webpage_default || function (
            options,
            onError
        ) {
        /*
         * this function will test webpage's default handling-behavior
         */
            options = { modeCoverageMerge: true, url: local.serverLocalHost + '?modeTest=1' };
            local.browserTest(options, onError);
        };
 
        // run test-server
        local.testRunServer(local);
        break;
    }
}());
 
 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
 
 
1
1
1
1
1
1
1
1
1
 
1
 
'use strict';
 
require('./string');
require('./number');
require('./array');
require('./enumerable');
require('./object');
require('./date');
require('./range');
require('./function');
require('./regexp');
 
module.exports = require('sugar-core');
 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
 
 
1
 
 
 
1
 
 
 
 
 
 
 
1
 
'use strict';
 
var Sugar = require('sugar-core'),
    arrayClone = require('./internal/arrayClone'),
    arrayAppend = require('./internal/arrayAppend');
 
Sugar.Array.defineInstance({
 
  'add': function(arr, item, index) {
    return arrayAppend(arrayClone(arr), item, index);
  }
 
});
 
module.exports = Sugar.Array.add;
 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
 
 
1
 
 
1
 
 
 
 
 
 
 
1
 
'use strict';
 
var Sugar = require('sugar-core'),
    arrayAppend = require('./internal/arrayAppend');
 
Sugar.Array.defineInstance({
 
  'append': function(arr, item, index) {
    return arrayAppend(arr, item, index);
  }
 
});
 
module.exports = Sugar.Array.append;
 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
 
 
1
 
 
1
 
 
 
 
 
 
 
1
 
'use strict';
 
var Sugar = require('sugar-core'),
    getEntriesForIndexes = require('../common/internal/getEntriesForIndexes');
 
Sugar.Array.defineInstance({
 
  'at': function(arr, index, loop) {
    return getEntriesForIndexes(arr, index, loop);
  }
 
});
 
module.exports = Sugar.Array.at;
 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
 
 
1
 
 
1
 
 
 
 
 
 
 
1
 
'use strict';
 
var Sugar = require('sugar-core'),
    average = require('../enumerable/internal/average');
 
Sugar.Array.defineInstance({
 
  'average': function(arr, map) {
    return average(arr, map);
  }
 
});
 
module.exports = Sugar.Array.average;
 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
 
 
1
 
 
1
 
 
 
 
 
 
 
1
 
'use strict';
 
var Sugar = require('sugar-core'),
    arrayClone = require('./internal/arrayClone');
 
Sugar.Array.defineInstance({
 
  'clone': function(arr) {
    return arrayClone(arr);
  }
 
});
 
module.exports = Sugar.Array.clone;
 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
 
 
1
 
 
1
 
 
 
 
 
 
 
1
 
'use strict';
 
var Sugar = require('sugar-core'),
    arrayCompact = require('./internal/arrayCompact');
 
Sugar.Array.defineInstance({
 
  'compact': function(arr, all) {
    return arrayCompact(arr, all);
  }
 
});
 
module.exports = Sugar.Array.compact;
 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
 
 
1
 
 
1
 
 
 
 
 
 
 
 
 
 
1
 
'use strict';
 
var Sugar = require('sugar-core'),
    coercePositiveInteger = require('../common/internal/coercePositiveInteger');
 
Sugar.Array.defineStatic({
 
  'construct': function(n, fn) {
    n = coercePositiveInteger(n);
    return Array.from(new Array(n), function(el, i) {
      return fn && fn(i);
    });
  }
 
});
 
module.exports = Sugar.Array.construct;
 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
 
 
1
 
 
 
1
 
 
 
 
 
1
 
'use strict';
 
var Sugar = require('sugar-core'),
    arrayCount = require('../enumerable/internal/arrayCount'),
    fixArgumentLength = require('../common/internal/fixArgumentLength');
 
Sugar.Array.defineInstance({
 
  'count': fixArgumentLength(arrayCount)
 
});
 
module.exports = Sugar.Array.count;
 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
 
 
1
 
 
1
 
1
 
 
 
 
 
 
 
1
 
'use strict';
 
var Sugar = require('sugar-core'),
    arrayCreate = require('./internal/arrayCreate');
 
require('./build/setArrayChainableConstructorCall');
 
Sugar.Array.defineStatic({
 
  'create': function(obj, clone) {
    return arrayCreate(obj, clone);
  }
 
});
 
module.exports = Sugar.Array.create;
 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
 
 
1
 
 
 
 
 
1
 
1
 
 
 
 
 
1
 
'use strict';
 
var Sugar = require('sugar-core'),
    ENHANCEMENTS_FLAG = require('../common/var/ENHANCEMENTS_FLAG'),
    ARRAY_ENHANCEMENTS_FLAG = require('../enumerable/var/ARRAY_ENHANCEMENTS_FLAG'),
    fixArgumentLength = require('../common/internal/fixArgumentLength'),
    enhancedMatcherMethods = require('../enumerable/var/enhancedMatcherMethods');
 
var enhancedEvery = enhancedMatcherMethods.enhancedEvery;
 
Sugar.Array.defineInstance({
 
  'every': fixArgumentLength(enhancedEvery)
 
}, [ENHANCEMENTS_FLAG, ARRAY_ENHANCEMENTS_FLAG]);
 
module.exports = Sugar.Array.every;
 

1
2
3
4
5
6
7
8
 
 
1
 
1
 
1
 
'use strict';
 
var Sugar = require('sugar-core');
 
require('../enumerable/build/buildFromIndexMethodsCall');
 
module.exports = Sugar.Array.everyFromIndex;
 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
 
 
1
 
 
1
 
 
 
 
 
 
 
1
 
'use strict';
 
var Sugar = require('sugar-core'),
    arrayExclude = require('./internal/arrayExclude');
 
Sugar.Array.defineInstance({
 
  'exclude': function(arr, f) {
    return arrayExclude(arr, f);
  }
 
});
 
module.exports = Sugar.Array.exclude;
 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
 
 
1
 
 
 
 
 
1
 
1
 
 
 
 
 
1
 
'use strict';
 
var Sugar = require('sugar-core'),
    ENHANCEMENTS_FLAG = require('../common/var/ENHANCEMENTS_FLAG'),
    ARRAY_ENHANCEMENTS_FLAG = require('../enumerable/var/ARRAY_ENHANCEMENTS_FLAG'),
    fixArgumentLength = require('../common/internal/fixArgumentLength'),
    enhancedMatcherMethods = require('../enumerable/var/enhancedMatcherMethods');
 
var enhancedFilter = enhancedMatcherMethods.enhancedFilter;
 
Sugar.Array.defineInstance({
 
  'filter': fixArgumentLength(enhancedFilter)
 
}, [ENHANCEMENTS_FLAG, ARRAY_ENHANCEMENTS_FLAG]);
 
module.exports = Sugar.Array.filter;
 

1
2
3
4
5
6
7
8
 
 
1
 
1
 
1
 
'use strict';
 
var Sugar = require('sugar-core');
 
require('../enumerable/build/buildFromIndexMethodsCall');
 
module.exports = Sugar.Array.filterFromIndex;
 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
 
 
1
 
 
 
 
 
1
 
1
 
 
 
 
 
1
 
'use strict';
 
var Sugar = require('sugar-core'),
    ENHANCEMENTS_FLAG = require('../common/var/ENHANCEMENTS_FLAG'),
    ARRAY_ENHANCEMENTS_FLAG = require('../enumerable/var/ARRAY_ENHANCEMENTS_FLAG'),
    fixArgumentLength = require('../common/internal/fixArgumentLength'),
    enhancedMatcherMethods = require('../enumerable/var/enhancedMatcherMethods');
 
var enhancedFind = enhancedMatcherMethods.enhancedFind;
 
Sugar.Array.defineInstance({
 
  'find': fixArgumentLength(enhancedFind)
 
}, [ENHANCEMENTS_FLAG, ARRAY_ENHANCEMENTS_FLAG]);
 
module.exports = Sugar.Array.find;
 

1
2
3
4
5
6
7
8
 
 
1
 
1
 
1
 
'use strict';
 
var Sugar = require('sugar-core');
 
require('../enumerable/build/buildFromIndexMethodsCall');
 
module.exports = Sugar.Array.findFromIndex;
 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
 
 
1
 
 
 
 
 
1
 
1
 
 
 
 
 
1
 
'use strict';
 
var Sugar = require('sugar-core'),
    ENHANCEMENTS_FLAG = require('../common/var/ENHANCEMENTS_FLAG'),
    ARRAY_ENHANCEMENTS_FLAG = require('../enumerable/var/ARRAY_ENHANCEMENTS_FLAG'),
    fixArgumentLength = require('../common/internal/fixArgumentLength'),
    enhancedMatcherMethods = require('../enumerable/var/enhancedMatcherMethods');
 
var enhancedFindIndex = enhancedMatcherMethods.enhancedFindIndex;
 
Sugar.Array.defineInstance({
 
  'findIndex': fixArgumentLength(enhancedFindIndex)
 
}, [ENHANCEMENTS_FLAG, ARRAY_ENHANCEMENTS_FLAG]);
 
module.exports = Sugar.Array.findIndex;
 

1
2
3
4
5
6
7
8
 
 
1
 
1
 
1
 
'use strict';
 
var Sugar = require('sugar-core');
 
require('../enumerable/build/buildFromIndexMethodsCall');
 
module.exports = Sugar.Array.findIndexFromIndex;
 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
 
 
1
 
 
1
 
 
 
 
 
 
 
 
 
1
 
'use strict';
 
var Sugar = require('sugar-core'),
    isUndefined = require('../common/internal/isUndefined');
 
Sugar.Array.defineInstance({
 
  'first': function(arr, num) {
    if (isUndefined(num)) return arr[0];
    if (num < 0) num = 0;
    return arr.slice(0, num);
  }
 
});
 
module.exports = Sugar.Array.first;
 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
 
 
1
 
 
1
 
 
 
 
 
 
 
1
 
'use strict';
 
var Sugar = require('sugar-core'),
    arrayFlatten = require('./internal/arrayFlatten');
 
Sugar.Array.defineInstance({
 
  'flatten': function(arr, limit) {
    return arrayFlatten(arr, limit);
  }
 
});
 
module.exports = Sugar.Array.flatten;
 

1
2
3
4
5
6
7
8
 
 
1
 
1
 
1
 
'use strict';
 
var Sugar = require('sugar-core');
 
require('../enumerable/build/buildFromIndexMethodsCall');
 
module.exports = Sugar.Array.forEachFromIndex;
 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
 
 
1
 
1
 
 
 
 
 
 
 
1
 
'use strict';
 
var Sugar = require('sugar-core');
 
Sugar.Array.defineInstance({
 
  'from': function(arr, num) {
    return arr.slice(num);
  }
 
});
 
module.exports = Sugar.Array.from;
 

1
2
3
4
5
6
7
8
9
 
 
1
 
 
1
 
1
 
'use strict';
 
var Sugar = require('sugar-core'),
    ARRAY_OPTIONS = require('./var/ARRAY_OPTIONS');
 
var _arrayOptions = ARRAY_OPTIONS._arrayOptions;
 
module.exports = Sugar.Array.getOption;
 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
 
 
1
 
 
1
 
 
 
 
 
 
 
1
 
'use strict';
 
var Sugar = require('sugar-core'),
    arrayGroupBy = require('./internal/arrayGroupBy');
 
Sugar.Array.defineInstance({
 
  'groupBy': function(arr, map, fn) {
    return arrayGroupBy(arr, map, fn);
  }
 
});
 
module.exports = Sugar.Array.groupBy;
 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
 
 
1
 
 
 
 
1
 
1
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
 
'use strict';
 
var Sugar = require('sugar-core'),
    isDefined = require('../common/internal/isDefined'),
    mathAliases = require('../common/var/mathAliases'),
    simpleRepeat = require('../common/internal/simpleRepeat');
 
var ceil = mathAliases.ceil;
 
Sugar.Array.defineInstance({
 
  'inGroups': function(arr, num, padding) {
    var pad = isDefined(padding);
    var result = new Array(num);
    var divisor = ceil(arr.length / num);
    simpleRepeat(num, function(i) {
      var index = i * divisor;
      var group = arr.slice(index, index + divisor);
      if (pad && group.length < divisor) {
        simpleRepeat(divisor - group.length, function() {
          group.push(padding);
        });
      }
      result[i] = group;
    });
    return result;
  }
 
});
 
module.exports = Sugar.Array.inGroups;
 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
 
 
1
 
 
 
 
1
 
1
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
 
'use strict';
 
var Sugar = require('sugar-core'),
    isUndefined = require('../common/internal/isUndefined'),
    mathAliases = require('../common/var/mathAliases'),
    simpleRepeat = require('../common/internal/simpleRepeat');
 
var ceil = mathAliases.ceil;
 
Sugar.Array.defineInstance({
 
  'inGroupsOf': function(arr, num, padding) {
    var result = [], len = arr.length, group;
    if (len === 0 || num === 0) return arr;
    if (isUndefined(num)) num = 1;
    if (isUndefined(padding)) padding = null;
    simpleRepeat(ceil(len / num), function(i) {
      group = arr.slice(num * i, num * i + num);
      while(group.length < num) {
        group.push(padding);
      }
      result.push(group);
    });
    return result;
  }
 
});
 
module.exports = Sugar.Array.inGroupsOf;
 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
 
 
 
1
1
 
 
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
 
 
1
 
 
1
1
 
1
 
'use strict';
 
// Static Methods
require('./construct');
require('./create');
 
// Instance Methods
require('./add');
require('./append');
require('./at');
require('./clone');
require('./compact');
require('./exclude');
require('./first');
require('./flatten');
require('./from');
require('./groupBy');
require('./inGroups');
require('./inGroupsOf');
require('./intersect');
require('./isEmpty');
require('./isEqual');
require('./last');
require('./remove');
require('./removeAt');
require('./sample');
require('./shuffle');
require('./sortBy');
require('./subtract');
require('./to');
require('./union');
require('./unique');
require('./zip');
 
// Aliases
require('./insert');
 
// Accessors
require('./getOption');
require('./setOption');
 
module.exports = require('sugar-core');
 

1
2
3
4
5
6
7
8
9
 
 
1
 
 
1
 
1
 
'use strict';
 
var Sugar = require('sugar-core'),
    append = require('./append');
 
Sugar.Array.alias('insert', 'append');
 
module.exports = Sugar.Array.insert;
 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
 
 
1
 
 
1
 
 
 
 
 
 
 
1
 
'use strict';
 
var Sugar = require('sugar-core'),
    arrayIntersectOrSubtract = require('./internal/arrayIntersectOrSubtract');
 
Sugar.Array.defineInstance({
 
  'intersect': function(arr1, arr2) {
    return arrayIntersectOrSubtract(arr1, arr2, false);
  }
 
});
 
module.exports = Sugar.Array.intersect;
 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
 
 
1
 
1
 
 
 
 
 
 
 
1
 
'use strict';
 
var Sugar = require('sugar-core');
 
Sugar.Array.defineInstance({
 
  'isEmpty': function(arr) {
    return arr.length === 0;
  }
 
});
 
module.exports = Sugar.Array.isEmpty;
 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
 
 
1
 
 
1
 
 
 
 
 
 
 
1
 
'use strict';
 
var Sugar = require('sugar-core'),
    isEqual = require('../common/internal/isEqual');
 
Sugar.Array.defineInstance({
 
  'isEqual': function(a, b) {
    return isEqual(a, b);
  }
 
});
 
module.exports = Sugar.Array.isEqual;
 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
 
 
1
 
 
1
 
 
 
 
 
 
 
 
 
1
 
'use strict';
 
var Sugar = require('sugar-core'),
    isUndefined = require('../common/internal/isUndefined');
 
Sugar.Array.defineInstance({
 
  'last': function(arr, num) {
    if (isUndefined(num)) return arr[arr.length - 1];
    var start = arr.length - num < 0 ? 0 : arr.length - num;
    return arr.slice(start);
  }
 
});
 
module.exports = Sugar.Array.last;
 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
 
 
1
 
 
1
 
 
 
 
 
 
 
1
 
'use strict';
 
var Sugar = require('sugar-core'),
    getLeastOrMost = require('../enumerable/internal/getLeastOrMost');
 
Sugar.Array.defineInstance({
 
  'least': function(arr, all, map) {
    return getLeastOrMost(arr, all, map);
  }
 
});
 
module.exports = Sugar.Array.least;
 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
 
 
1
 
 
 
 
 
1
 
 
 
 
 
1
 
'use strict';
 
var Sugar = require('sugar-core'),
    ENHANCEMENTS_FLAG = require('../common/var/ENHANCEMENTS_FLAG'),
    ARRAY_ENHANCEMENTS_FLAG = require('../enumerable/var/ARRAY_ENHANCEMENTS_FLAG'),
    enhancedMap = require('../enumerable/var/enhancedMap'),
    fixArgumentLength = require('../common/internal/fixArgumentLength');
 
Sugar.Array.defineInstance({
 
  'map': fixArgumentLength(enhancedMap)
 
}, [ENHANCEMENTS_FLAG, ARRAY_ENHANCEMENTS_FLAG]);
 
module.exports = Sugar.Array.map;
 

1
2
3
4
5
6
7
8
 
 
1
 
1
 
1
 
'use strict';
 
var Sugar = require('sugar-core');
 
require('../enumerable/build/buildFromIndexMethodsCall');
 
module.exports = Sugar.Array.mapFromIndex;
 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
 
 
1
 
 
1
 
 
 
 
 
 
 
1
 
'use strict';
 
var Sugar = require('sugar-core'),
    getMinOrMax = require('../enumerable/internal/getMinOrMax');
 
Sugar.Array.defineInstance({
 
  'max': function(arr, all, map) {
    return getMinOrMax(arr, all, map, true);
  }
 
});
 
module.exports = Sugar.Array.max;
 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
 
 
1
 
 
1
 
 
 
 
 
 
 
1
 
'use strict';
 
var Sugar = require('sugar-core'),
    median = require('../enumerable/internal/median');
 
Sugar.Array.defineInstance({
 
  'median': function(arr, map) {
    return median(arr, map);
  }
 
});
 
module.exports = Sugar.Array.median;
 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
 
 
1
 
 
1
 
 
 
 
 
 
 
1
 
'use strict';
 
var Sugar = require('sugar-core'),
    getMinOrMax = require('../enumerable/internal/getMinOrMax');
 
Sugar.Array.defineInstance({
 
  'min': function(arr, all, map) {
    return getMinOrMax(arr, all, map);
  }
 
});
 
module.exports = Sugar.Array.min;
 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
 
 
1
 
 
1
 
 
 
 
 
 
 
1
 
'use strict';
 
var Sugar = require('sugar-core'),
    getLeastOrMost = require('../enumerable/internal/getLeastOrMost');
 
Sugar.Array.defineInstance({
 
  'most': function(arr, all, map) {
    return getLeastOrMost(arr, all, map, true);
  }
 
});
 
module.exports = Sugar.Array.most;
 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
 
 
1
 
 
 
1
 
 
 
 
 
1
 
'use strict';
 
var Sugar = require('sugar-core'),
    arrayNone = require('../enumerable/internal/arrayNone'),
    fixArgumentLength = require('../common/internal/fixArgumentLength');
 
Sugar.Array.defineInstance({
 
  'none': fixArgumentLength(arrayNone)
 
});
 
module.exports = Sugar.Array.none;
 

1
2
3
4
5
6
7
8
 
 
1
 
1
 
1
 
'use strict';
 
var Sugar = require('sugar-core');
 
require('../enumerable/build/buildFromIndexMethodsCall');
 
module.exports = Sugar.Array.reduceFromIndex;
 

1
2
3
4
5
6
7
8
 
 
1
 
1
 
1
 
'use strict';
 
var Sugar = require('sugar-core');
 
require('../enumerable/build/buildFromIndexMethodsCall');
 
module.exports = Sugar.Array.reduceRightFromIndex;
 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
 
 
1
 
 
1
 
 
 
 
 
 
 
1
 
'use strict';
 
var Sugar = require('sugar-core'),
    arrayRemove = require('./internal/arrayRemove');
 
Sugar.Array.defineInstance({
 
  'remove': function(arr, f) {
    return arrayRemove(arr, f);
  }
 
});
 
module.exports = Sugar.Array.remove;
 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
 
 
1
 
 
1
 
 
 
 
 
 
 
 
 
 
1
 
'use strict';
 
var Sugar = require('sugar-core'),
    isUndefined = require('../common/internal/isUndefined');
 
Sugar.Array.defineInstance({
 
  'removeAt': function(arr, start, end) {
    if (isUndefined(start)) return arr;
    if (isUndefined(end))   end = start;
    arr.splice(start, end - start + 1);
    return arr;
  }
 
});
 
module.exports = Sugar.Array.removeAt;
 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
 
 
1
 
 
 
 
 
 
1
 
 
1
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
 
'use strict';
 
var Sugar = require('sugar-core'),
    trunc = require('../common/var/trunc'),
    arrayClone = require('./internal/arrayClone'),
    classChecks = require('../common/var/classChecks'),
    isUndefined = require('../common/internal/isUndefined'),
    mathAliases = require('../common/var/mathAliases');
 
var isBoolean = classChecks.isBoolean,
    min = mathAliases.min;
 
Sugar.Array.defineInstance({
 
  'sample': function(arr, arg1, arg2) {
    var result = [], num, remove, single;
    if (isBoolean(arg1)) {
      remove = arg1;
    } else {
      num = arg1;
      remove = arg2;
    }
    if (isUndefined(num)) {
      num = 1;
      single = true;
    }
    if (!remove) {
      arr = arrayClone(arr);
    }
    num = min(num, arr.length);
    for (var i = 0, index; i < num; i++) {
      index = trunc(Math.random() * arr.length);
      result.push(arr[index]);
      arr.splice(index, 1);
    }
    return single ? result[0] : result;
  }
 
});
 
module.exports = Sugar.Array.sample;
 

1
2
3
4
5
6
7
8
9
 
 
1
 
 
1
 
1
 
'use strict';
 
var Sugar = require('sugar-core'),
    ARRAY_OPTIONS = require('./var/ARRAY_OPTIONS');
 
var _arrayOptions = ARRAY_OPTIONS._arrayOptions;
 
module.exports = Sugar.Array.setOption;
 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
 
 
1
 
 
1
 
 
 
 
 
 
 
1
 
'use strict';
 
var Sugar = require('sugar-core'),
    arrayShuffle = require('./internal/arrayShuffle');
 
Sugar.Array.defineInstance({
 
  'shuffle': function(arr) {
    return arrayShuffle(arr);
  }
 
});
 
module.exports = Sugar.Array.shuffle;
 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
 
 
1
 
 
 
 
 
1
 
1
 
 
 
 
 
1
 
'use strict';
 
var Sugar = require('sugar-core'),
    ENHANCEMENTS_FLAG = require('../common/var/ENHANCEMENTS_FLAG'),
    ARRAY_ENHANCEMENTS_FLAG = require('../enumerable/var/ARRAY_ENHANCEMENTS_FLAG'),
    fixArgumentLength = require('../common/internal/fixArgumentLength'),
    enhancedMatcherMethods = require('../enumerable/var/enhancedMatcherMethods');
 
var enhancedSome = enhancedMatcherMethods.enhancedSome;
 
Sugar.Array.defineInstance({
 
  'some': fixArgumentLength(enhancedSome)
 
}, [ENHANCEMENTS_FLAG, ARRAY_ENHANCEMENTS_FLAG]);
 
module.exports = Sugar.Array.some;
 

1
2
3
4
5
6
7
8
 
 
1
 
1
 
1
 
'use strict';
 
var Sugar = require('sugar-core');
 
require('../enumerable/build/buildFromIndexMethodsCall');
 
module.exports = Sugar.Array.someFromIndex;
 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
 
 
1
 
 
 
1
 
 
 
 
 
 
 
 
 
 
 
 
1
 
'use strict';
 
var Sugar = require('sugar-core'),
    compareValue = require('./internal/compareValue'),
    mapWithShortcuts = require('../common/internal/mapWithShortcuts');
 
Sugar.Array.defineInstance({
 
  'sortBy': function(arr, map, desc) {
    arr.sort(function(a, b) {
      var aProperty = mapWithShortcuts(a, map, arr, [a]);
      var bProperty = mapWithShortcuts(b, map, arr, [b]);
      return compareValue(aProperty, bProperty) * (desc ? -1 : 1);
    });
    return arr;
  }
 
});
 
module.exports = Sugar.Array.sortBy;
 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
 
 
1
 
 
1
 
 
 
 
 
 
 
1
 
'use strict';
 
var Sugar = require('sugar-core'),
    arrayIntersectOrSubtract = require('./internal/arrayIntersectOrSubtract');
 
Sugar.Array.defineInstance({
 
  'subtract': function(arr, item) {
    return arrayIntersectOrSubtract(arr, item, true);
  }
 
});
 
module.exports = Sugar.Array.subtract;
 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
 
 
1
 
 
1
 
 
 
 
 
 
 
1
 
'use strict';
 
var Sugar = require('sugar-core'),
    sum = require('../enumerable/internal/sum');
 
Sugar.Array.defineInstance({
 
  'sum': function(arr, map) {
    return sum(arr, map);
  }
 
});
 
module.exports = Sugar.Array.sum;
 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
 
 
1
 
 
1
 
 
 
 
 
 
 
 
1
 
'use strict';
 
var Sugar = require('sugar-core'),
    isUndefined = require('../common/internal/isUndefined');
 
Sugar.Array.defineInstance({
 
  'to': function(arr, num) {
    if (isUndefined(num)) num = arr.length;
    return arr.slice(0, num);
  }
 
});
 
module.exports = Sugar.Array.to;
 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
 
 
1
 
 
 
1
 
 
 
 
 
 
 
1
 
'use strict';
 
var Sugar = require('sugar-core'),
    arrayUnique = require('./internal/arrayUnique'),
    arrayConcat = require('./internal/arrayConcat');
 
Sugar.Array.defineInstance({
 
  'union': function(arr1, arr2) {
    return arrayUnique(arrayConcat(arr1, arr2));
  }
 
});
 
module.exports = Sugar.Array.union;
 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
 
 
1
 
 
1
 
 
 
 
 
 
 
1
 
'use strict';
 
var Sugar = require('sugar-core'),
    arrayUnique = require('./internal/arrayUnique');
 
Sugar.Array.defineInstance({
 
  'unique': function(arr, map) {
    return arrayUnique(arr, map);
  }
 
});
 
module.exports = Sugar.Array.unique;
 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
 
 
1
 
 
1
 
 
 
 
 
 
 
 
 
 
 
1
 
'use strict';
 
var Sugar = require('sugar-core'),
    map = require('../common/internal/map');
 
Sugar.Array.defineInstanceWithArguments({
 
  'zip': function(arr, args) {
    return map(arr, function(el, i) {
      return [el].concat(map(args, function(k) {
        return (i in k) ? k[i] : null;
      }));
    });
  }
 
});
 
module.exports = Sugar.Array.zip;
 

1
2
3
4
5
6
 
 
1
 
1
 
'use strict';
 
var setArrayChainableConstructor = require('../internal/setArrayChainableConstructor');
 
setArrayChainableConstructor();
 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
 
 
1
 
1
 
 
 
 
 
 
 
 
 
 
 
 
 
1
 
'use strict';
 
var isDefined = require('../../common/internal/isDefined');
 
function arrayAppend(arr, el, index) {
  var spliceArgs;
  index = +index;
  if (isNaN(index)) {
    index = arr.length;
  }
  spliceArgs = [index, 0];
  if (isDefined(el)) {
    spliceArgs = spliceArgs.concat(el);
  }
  arr.splice.apply(arr, spliceArgs);
  return arr;
}
 
module.exports = arrayAppend;
 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
 
 
1
 
1
 
 
 
 
 
 
 
1
 
'use strict';
 
var forEach = require('../../common/internal/forEach');
 
function arrayClone(arr) {
  var clone = new Array(arr.length);
  forEach(arr, function(el, i) {
    clone[i] = el;
  });
  return clone;
}
 
module.exports = arrayClone;
 

1
2
3
4
5
6
7
8
9
10
11
12
 
 
1
 
1
 
 
 
 
 
1
 
'use strict';
 
var filter = require('../../common/internal/filter');
 
function arrayCompact(arr, all) {
  return filter(arr, function(el) {
    return el || (!all && el != null && el.valueOf() === el.valueOf());
  });
}
 
module.exports = arrayCompact;
 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
 
 
1
 
 
1
 
 
 
 
 
 
1
 
'use strict';
 
var HAS_CONCAT_BUG = require('../var/HAS_CONCAT_BUG'),
    arraySafeConcat = require('./arraySafeConcat');
 
function arrayConcat(arr1, arr2) {
  if (HAS_CONCAT_BUG) {
    return arraySafeConcat(arr1, arr2);
  }
  return arr1.concat(arr2);
}
 
module.exports = arrayConcat;
 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
 
 
1
 
 
 
 
 
1
 
1
 
 
 
 
 
 
 
 
 
 
 
1
 
'use strict';
 
var isDefined = require('../../common/internal/isDefined'),
    arrayClone = require('./arrayClone'),
    classChecks = require('../../common/var/classChecks'),
    isObjectType = require('../../common/internal/isObjectType'),
    isArrayOrInherited = require('./isArrayOrInherited');
 
var isString = classChecks.isString;
 
function arrayCreate(obj, clone) {
  var arr;
  if (isArrayOrInherited(obj)) {
    arr = clone ? arrayClone(obj) : obj;
  } else if (isObjectType(obj) || isString(obj)) {
    arr = Array.from(obj);
  } else if (isDefined(obj)) {
    arr = [obj];
  }
  return arr || [];
}
 
module.exports = arrayCreate;
 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
 
 
1
 
1
 
 
 
 
 
 
 
 
 
1
 
'use strict';
 
var getMatcher = require('../../common/internal/getMatcher');
 
function arrayExclude(arr, f) {
  var result = [], matcher = getMatcher(f);
  for (var i = 0; i < arr.length; i++) {
    if (!matcher(arr[i], i, arr)) {
      result.push(arr[i]);
    }
  }
  return result;
}
 
module.exports = arrayExclude;
 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
 
 
1
 
 
1
 
1
 
 
 
 
 
 
 
 
 
 
 
 
 
1
 
'use strict';
 
var forEach = require('../../common/internal/forEach'),
    classChecks = require('../../common/var/classChecks');
 
var isArray = classChecks.isArray;
 
function arrayFlatten(arr, level, current) {
  var result = [];
  level = level || Infinity;
  current = current || 0;
  forEach(arr, function(el) {
    if (isArray(el) && current < level) {
      result = result.concat(arrayFlatten(el, level, current + 1));
    } else {
      result.push(el);
    }
  });
  return result;
}
 
module.exports = arrayFlatten;
 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
 
 
1
 
 
 
1
 
 
1
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
 
'use strict';
 
var forEach = require('../../common/internal/forEach'),
    mapWithShortcuts = require('../../common/internal/mapWithShortcuts'),
    coreUtilityAliases = require('../../common/var/coreUtilityAliases');
 
var hasOwn = coreUtilityAliases.hasOwn,
    forEachProperty = coreUtilityAliases.forEachProperty;
 
function arrayGroupBy(arr, map, fn) {
  var result = {}, key;
  forEach(arr, function(el, i) {
    key = mapWithShortcuts(el, map, arr, [el, i, arr]);
    if (!hasOwn(result, key)) {
      result[key] = [];
    }
    result[key].push(el);
  });
  if (fn) {
    forEachProperty(result, fn);
  }
  return result;
}
 
module.exports = arrayGroupBy;
 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
 
 
1
 
 
 
 
 
1
 
 
1
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
 
'use strict';
 
var forEach = require('../../common/internal/forEach'),
    arrayWrap = require('./arrayWrap'),
    classChecks = require('../../common/var/classChecks'),
    serializeInternal = require('../../common/internal/serializeInternal'),
    coreUtilityAliases = require('../../common/var/coreUtilityAliases');
 
var isArray = classChecks.isArray,
    hasOwn = coreUtilityAliases.hasOwn;
 
function arrayIntersectOrSubtract(arr1, arr2, subtract) {
  var result = [], obj = {}, refs = [];
  if (!isArray(arr2)) {
    arr2 = arrayWrap(arr2);
  }
  forEach(arr2, function(el) {
    obj[serializeInternal(el, refs)] = true;
  });
  forEach(arr1, function(el) {
    var key = serializeInternal(el, refs);
    if (hasOwn(obj, key) !== subtract) {
      delete obj[key];
      result.push(el);
    }
  });
  return result;
}
 
module.exports = arrayIntersectOrSubtract;
 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
 
 
1
 
1
 
 
 
 
 
 
 
 
 
 
 
1
 
'use strict';
 
var getMatcher = require('../../common/internal/getMatcher');
 
function arrayRemove(arr, f) {
  var matcher = getMatcher(f), i = 0;
  while(i < arr.length) {
    if (matcher(arr[i], i, arr)) {
      arr.splice(i, 1);
    } else {
      i++;
    }
  }
  return arr;
}
 
module.exports = arrayRemove;
 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
 
 
1
 
 
 
1
 
1
 
 
 
 
 
 
 
 
 
1
 
'use strict';
 
var forEach = require('../../common/internal/forEach'),
    arrayClone = require('./arrayClone'),
    classChecks = require('../../common/var/classChecks');
 
var isArray = classChecks.isArray;
 
function arraySafeConcat(arr, arg) {
  var result = arrayClone(arr), len = result.length, arr2;
  arr2 = isArray(arg) ? arg : [arg];
  result.length += arr2.length;
  forEach(arr2, function(el, i) {
    result[len + i] = el;
  });
  return result;
}
 
module.exports = arraySafeConcat;
 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
 
 
1
 
1
 
 
 
 
 
 
 
 
 
 
 
1
 
'use strict';
 
var arrayClone = require('./arrayClone');
 
function arrayShuffle(arr) {
  arr = arrayClone(arr);
  var i = arr.length, j, x;
  while(i) {
    j = (Math.random() * i) | 0;
    x = arr[--i];
    arr[i] = arr[j];
    arr[j] = x;
  }
  return arr;
}
 
module.exports = arrayShuffle;
 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
 
 
1
 
 
 
 
1
 
1
 
 
 
 
 
 
 
 
 
 
 
 
1
 
'use strict';
 
var forEach = require('../../common/internal/forEach'),
    mapWithShortcuts = require('../../common/internal/mapWithShortcuts'),
    serializeInternal = require('../../common/internal/serializeInternal'),
    coreUtilityAliases = require('../../common/var/coreUtilityAliases');
 
var hasOwn = coreUtilityAliases.hasOwn;
 
function arrayUnique(arr, map) {
  var result = [], obj = {}, refs = [];
  forEach(arr, function(el, i) {
    var transformed = map ? mapWithShortcuts(el, map, arr, [el, i, arr]) : el;
    var key = serializeInternal(transformed, refs);
    if (!hasOwn(obj, key)) {
      result.push(el);
      obj[key] = true;
    }
  });
  return result;
}
 
module.exports = arrayUnique;
 

1
2
3
4
5
6
7
8
9
10
 
 
1
 
 
 
 
 
1
 
'use strict';
 
function arrayWrap(obj) {
  var arr = [];
  arr.push(obj);
  return arr;
}
 
module.exports = arrayWrap;
 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
 
 
1
 
 
 
1
 
 
1
 
 
 
 
1
 
'use strict';
 
var HALF_WIDTH_NINE = require('../var/HALF_WIDTH_NINE'),
    FULL_WIDTH_NINE = require('../var/FULL_WIDTH_NINE'),
    CommonChars = require('../../common/var/CommonChars');
 
var HALF_WIDTH_ZERO = CommonChars.HALF_WIDTH_ZERO,
    FULL_WIDTH_ZERO = CommonChars.FULL_WIDTH_ZERO;
 
function codeIsNumeral(code) {
  return (code >= HALF_WIDTH_ZERO && code <= HALF_WIDTH_NINE) ||
         (code >= FULL_WIDTH_ZERO && code <= FULL_WIDTH_NINE);
}
 
module.exports = codeIsNumeral;
 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
 
 
1
 
 
1
 
 
 
1
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
 
'use strict';
 
var ARRAY_OPTIONS = require('../var/ARRAY_OPTIONS'),
    classChecks = require('../../common/var/classChecks');
 
var isString = classChecks.isString,
    isArray = classChecks.isArray,
    _arrayOptions = ARRAY_OPTIONS._arrayOptions;
 
function compareValue(aVal, bVal) {
  var cmp, i, collate;
  if (isString(aVal) && isString(bVal)) {
    collate = _arrayOptions('sortCollate');
    return collate(aVal, bVal);
  } else if (isArray(aVal) && isArray(bVal)) {
    if (aVal.length < bVal.length) {
      return -1;
    } else if (aVal.length > bVal.length) {
      return 1;
    } else {
      for(i = 0; i < aVal.length; i++) {
        cmp = compareValue(aVal[i], bVal[i]);
        if (cmp !== 0) {
          return cmp;
        }
      }
      return 0;
    }
  }
  return aVal < bVal ? -1 : aVal > bVal ? 1 : 0;
}
 
module.exports = compareValue;
 

1
2
3
4
5
6
7
8
9
10
11
12
13
 
 
1
 
1
 
1
 
 
 
 
1
 
'use strict';
 
var coreUtilityAliases = require('../../common/var/coreUtilityAliases');
 
var getOwn = coreUtilityAliases.getOwn;
 
function getCollationCharacter(str, index, sortEquivalents) {
  var chr = str.charAt(index);
  return getOwn(sortEquivalents, chr) || chr;
}
 
module.exports = getCollationCharacter;
 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
 
 
1
 
1
 
1
 
 
 
 
 
 
 
 
 
 
1
 
'use strict';
 
var classChecks = require('../../common/var/classChecks');
 
var isString = classChecks.isString;
 
function getCollationReadyString(str, sortIgnore, sortIgnoreCase) {
  if (!isString(str)) str = String(str);
  if (sortIgnoreCase) {
    str = str.toLowerCase();
  }
  if (sortIgnore) {
    str = str.replace(sortIgnore, '');
  }
  return str;
}
 
module.exports = getCollationReadyString;
 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
 
 
1
 
 
1
1
1
7
7
25
25
 
 
1
 
 
1
 
'use strict';
 
var forEach = require('../../common/internal/forEach'),
    spaceSplit = require('../../common/internal/spaceSplit');
 
function getSortEquivalents() {
  var equivalents = {};
  forEach(spaceSplit('AÁÀÂÃÄ CÇ EÉÈÊË IÍÌİÎÏ OÓÒÔÕÖ Sß UÚÙÛÜ'), function(set) {
    var first = set.charAt(0);
    forEach(set.slice(1).split(''), function(chr) {
      equivalents[chr] = first;
      equivalents[chr.toLowerCase()] = first.toLowerCase();
    });
  });
  return equivalents;
}
 
module.exports = getSortEquivalents;
 

1
2
3
4
5
6
7
8
9
10
11
12
13
 
 
1
 
1
1
1
78
 
 
 
1
 
'use strict';
 
var map = require('../../common/internal/map');
 
function getSortOrder() {
  var order = 'AÁÀÂÃĄBCĆČÇDĎÐEÉÈĚÊËĘFGĞHıIÍÌİÎÏJKLŁMNŃŇÑOÓÒÔPQRŘSŚŠŞTŤUÚÙŮÛÜVWXYÝZŹŻŽÞÆŒØÕÅÄÖ';
  return map(order.split(''), function(str) {
    return str + str.toLowerCase();
  }).join('');
}
 
module.exports = getSortOrder;
 

1
2
3
4
5
6
7
8
9
10
11
12
 
 
1
 
 
 
 
 
 
 
1
 
'use strict';
 
function getSortOrderIndex(chr, sortOrder) {
  if (!chr) {
    return null;
  } else {
    return sortOrder.indexOf(chr);
  }
}
 
module.exports = getSortOrderIndex;
 

1
2
3
4
5
6
7
8
9
10
11
12
 
 
1
 
1
 
1
 
 
 
1
 
'use strict';
 
var classChecks = require('../../common/var/classChecks');
 
var isArray = classChecks.isArray;
 
function isArrayOrInherited(obj) {
  return obj && obj.constructor && isArray(obj.constructor.prototype);
}
 
module.exports = isArrayOrInherited;
 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
 
 
1
 
 
 
1
 
1
1
 
 
1
 
'use strict';
 
var arrayCreate = require('./arrayCreate'),
    namespaceAliases = require('../../common/var/namespaceAliases'),
    setChainableConstructor = require('../../common/internal/setChainableConstructor');
 
var sugarArray = namespaceAliases.sugarArray;
 
function setArrayChainableConstructor() {
  setChainableConstructor(sugarArray, arrayCreate);
}
 
module.exports = setArrayChainableConstructor;
 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
 
 
1
 
 
 
 
 
 
 
 
 
1
 
1
 
 
 
 
 
 
 
 
1
 
1
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
 
 
 
 
'use strict';
 
var getSortOrder = require('../internal/getSortOrder'),
    codeIsNumeral = require('../internal/codeIsNumeral'),
    stringToNumber = require('../../common/internal/stringToNumber'),
    namespaceAliases = require('../../common/var/namespaceAliases'),
    getSortOrderIndex = require('../internal/getSortOrderIndex'),
    getSortEquivalents = require('../internal/getSortEquivalents'),
    defineOptionsAccessor = require('../../common/internal/defineOptionsAccessor'),
    getCollationCharacter = require('../internal/getCollationCharacter'),
    getCollationReadyString = require('../internal/getCollationReadyString');
 
var sugarArray = namespaceAliases.sugarArray;
 
var ARRAY_OPTIONS = {
  'sortIgnore':      null,
  'sortNatural':     true,
  'sortIgnoreCase':  true,
  'sortOrder':       getSortOrder(),
  'sortCollate':     collateStrings,
  'sortEquivalents': getSortEquivalents()
};
 
var _arrayOptions = defineOptionsAccessor(sugarArray, ARRAY_OPTIONS);
 
function collateStrings(a, b) {
  var aValue, bValue, aChar, bChar, aEquiv, bEquiv, index = 0, tiebreaker = 0;
 
  var sortOrder       = _arrayOptions('sortOrder');
  var sortIgnore      = _arrayOptions('sortIgnore');
  var sortNatural     = _arrayOptions('sortNatural');
  var sortIgnoreCase  = _arrayOptions('sortIgnoreCase');
  var sortEquivalents = _arrayOptions('sortEquivalents');
 
  a = getCollationReadyString(a, sortIgnore, sortIgnoreCase);
  b = getCollationReadyString(b, sortIgnore, sortIgnoreCase);
 
  do {
 
    aChar  = getCollationCharacter(a, index, sortEquivalents);
    bChar  = getCollationCharacter(b, index, sortEquivalents);
    aValue = getSortOrderIndex(aChar, sortOrder);
    bValue = getSortOrderIndex(bChar, sortOrder);
 
    if (aValue === -1 || bValue === -1) {
      aValue = a.charCodeAt(index) || null;
      bValue = b.charCodeAt(index) || null;
      if (sortNatural && codeIsNumeral(aValue) && codeIsNumeral(bValue)) {
        aValue = stringToNumber(a.slice(index));
        bValue = stringToNumber(b.slice(index));
      }
    } else {
      aEquiv = aChar !== a.charAt(index);
      bEquiv = bChar !== b.charAt(index);
      if (aEquiv !== bEquiv && tiebreaker === 0) {
        tiebreaker = aEquiv - bEquiv;
      }
    }
    index += 1;
  } while(aValue != null && bValue != null && aValue === bValue);
  if (aValue === bValue) return tiebreaker;
  return aValue - bValue;
}
 
module.exports = {
  ARRAY_OPTIONS: ARRAY_OPTIONS,
  _arrayOptions: _arrayOptions
};
 

1
2
3
4
 
 
1
 
'use strict';
 
module.exports = 0xff19;
 

1
2
3
4
 
 
1
 
'use strict';
 
module.exports = 0x39;
 

1
2
3
4
 
 
1
 
'use strict';
 
module.exports = !('0' in [].concat(undefined).concat());